home *** CD-ROM | disk | FTP | other *** search
/ The Games Machine 76 / XENIATGM66.iso / Indiana Jones / Indiana Jones.exe / RESOURCE / PREVIEW.GOB / cog_pru_stairpit2.cog < prev    next >
Text File  |  1999-11-15  |  12KB  |  444 lines
  1. # Jones 3D Cog Script
  2. #
  3. # PRU_stairpit.cog
  4. # 
  5. # Blocks will push you into the pit if you aren't careful.  They also form a stairway out. 
  6. # 
  7. # [GGJ] [PKM]
  8. #
  9. # (C) 1998 LucasArts Entertainment Co. All Rights Reserved
  10. # ========================================================================================
  11.  
  12. symbols
  13.     message entered
  14.     message pulse
  15.     message    arrived
  16.     message    timer
  17.     message touched
  18.     message    exited
  19.     message    startup
  20.     message    blocked
  21.  
  22.     thing   block0
  23.     thing   block1          
  24.     thing   block2
  25.     thing   block3        mask=0x409
  26.     thing   block4        mask=0x409
  27.     thing   block5        mask=0x409
  28.     #thing   block6
  29.     
  30.     thing    fakeBlock0
  31.     thing    fakeBlock1
  32.     thing    fakeBlock2
  33.     thing    fakeBlock3
  34.     thing    fakeBlock4
  35.     thing    fakeBlock5
  36.     #thing    fakeBlock6
  37.     
  38.     thing    blockGhost0
  39.     thing    blockGhost1
  40.     thing    blockGhost2
  41.     thing    blockGhost3
  42.     thing    blockGhost4
  43.     thing    blockGhost5
  44.     #thing    blockGhost6
  45.     
  46.     thing    backGhost0
  47.     thing    backGhost1
  48.     thing    backGhost2
  49.     thing    backGhost3
  50.     thing    backGhost4
  51.     thing    backGhost5
  52.     #thing    backGhost6
  53.     
  54.     thing    player                local
  55.     
  56.     float   moveSpeed=4.0            // How long it takes to push out (was) how fast the blocks push out
  57.     float    retractSpeed=0.5         //how fast they retrack if you jump back the way you came
  58.     float    autoRetractSpeed=3.0    //how fast they retrack automatically, after they're all out
  59.     float   pulseTime=3.0            //after a block starts pushing out, pause before next one starts
  60.     float    autoRetract=10.0        //delay before blocks start retracting automatically
  61.         
  62.     int     counter=0            local
  63.     int        retractCounter=5    local
  64.     int     crosscheck=0         local
  65.     int        out=0                local
  66.     
  67.     
  68.     flex    f_XDist                local
  69.     flex    f_YDist                local
  70.     flex    f_ZDist                local
  71.     thing    invisiBox=-1        local          mask=0x080
  72.     vector    v_modvec            local
  73.     vector    v_targetpos            local
  74.     sector    targetsector        local
  75.     
  76.     template    boxTpl        #currently set in Marcus to "1M oil drum c," will be changed to "1M aimable invisible cube."                             
  77.     
  78.     surface    hangR0        linkID=1    #with your back to the wall these hang ledges are to your right
  79.     surface    hangR1        linkID=1
  80.     surface    hangR2        linkID=1
  81.     surface    hangR3        linkID=1
  82.     surface    hangR4        linkID=1
  83.     
  84.     surface    hangL0        linkID=1    #with your back to the wall these hang ledges are to your left
  85.     surface    hangL1        linkID=1
  86.     surface    hangL2        linkID=1
  87.     surface    hangL3        linkID=1
  88.     surface    hangL4        linkID=1
  89.     surface    hangL5        linkID=1
  90.     
  91.     surface    hangE0        linkID=1
  92.     surface    hangE1        linkID=1
  93.     surface    hangE2        linkID=1
  94.     surface    hangE3        linkID=1
  95.     surface    hangE4        linkID=1
  96.     surface    hangE5        linkID=1
  97.     #surface    hangE6        linkID=1
  98.     
  99.     surface    musTrigger
  100.  
  101.     flex hangDistR0=0.5            local
  102.     flex hangDistR1=0.4            local
  103.     flex hangDistR2=0.3            local
  104.     flex hangDistR3=0.2            local
  105.     flex hangDistR4=0.1            local
  106.  
  107.     flex hangDistL0=-0.6        local
  108.     flex hangDistL1=-0.5        local
  109.     flex hangDistL2=-0.4        local
  110.     flex hangDistL3=-0.3        local
  111.     flex hangDistL4=-0.2        local
  112.     flex hangDistL5=-0.1        local
  113.  
  114.     int currentBlock        local
  115.     int currentSurface        local
  116.     int    bSurfaceFound        local
  117.     int    hanging=0            local
  118.     
  119.     int    bBlockFound=0        local
  120.     int out0=0                local
  121.     int out1=0                local
  122.     int out2=0                local
  123.     int out3=0                local
  124.     int out4=0                local
  125.     int out5=0                local
  126.     int out6=0                local
  127.     int    musOnce=0            local
  128.     
  129.     surface triggerface     mask=0x405
  130.     surface    retractface        mask=0x405
  131.     
  132.     sound    blocksnd=olv_quetzdoor_move_c.wav    local        #fol_in_scrapehard_long.wav      local
  133.     sound    musStairpit=mus_gen_awechord1.wav    local
  134. end
  135. # ========================================================================================
  136. code
  137.  
  138. startup:
  139.  
  140.     player = GetLocalPlayerThing();
  141.  
  142.     # When the blocks are in the wall, they should be "fakeblocks" so that Indy can't hang from them.
  143.     for (currentBlock = 0; (currentBlock <= 5); currentBlock = currentBlock + 1)
  144.     {
  145.         SetThingFlags(block0[currentBlock], 0x80000);
  146.     }
  147.     #SetCollideType(block5, 3);
  148.     #SetCollideType(block4, 3);
  149.     #SetCollideType(block3, 3);
  150.  
  151.  
  152.     return;
  153.  
  154. # ========================================================================================
  155. entered:
  156.  
  157.     # We only care about entered messages from surfaces.
  158.     if (GetSenderType() != 6) return;
  159.  
  160.     if ((GetSenderRef() == musTrigger) && (musOnce == 0))
  161.     {
  162.         musOnce = 1;
  163.         PlaySoundLocal(musStairpit, 1.0, 0.0, 0x0, 0);
  164.     }
  165.     
  166.     # Indy lands on the second platform.
  167.     if ((GetSenderRef() == triggerface) && (crosscheck == 0))
  168.     {
  169.         crosscheck = 1;
  170.  
  171.         # Remove the fake block and add blocks you can hang from.
  172.         SetThingFlags(fakeBlock0[0], 0x80000);
  173.         ClearThingFlags(block0[0], 0x80000);
  174.  
  175.         # The first block starts to move, and the pulse will trigger the rest.
  176.         MoveThingtoPos(block0, GetThingPos(blockGhost0), movespeed);
  177.         out0[0] = 0;
  178.         #PlaySoundThing(blocksnd, block0, 1.0, 7.5, 30.0, 0);
  179.         SetPulse(pulseTime);
  180.         return;
  181.     }
  182.         
  183.     # If Indy jumps back to the entrance
  184.     if ((GetSenderRef() == retractface) && (crosscheck == 1))
  185.     {
  186.         
  187.         Print("entered retract trigger-surface");
  188.         # Shut off the pulse.
  189.         SetPulse(0);
  190.         counter = 0;
  191.         crosscheck = 0;
  192.         retractCounter = 5;
  193.         
  194.         # Move the blocks back.
  195.         for (currentBlock = 0; (currentBlock <= 6); currentBlock = currentBlock + 1)
  196.         {
  197.             MoveThingToPos(block0[currentBlock], GetThingPos(backGhost0[currentBlock]), retractSpeed);
  198.             out0[currentBlock] = 1;
  199.         }
  200.         return;
  201.     }
  202.  
  203.     # Code below checks to see if Indy is hanging from a platform at the base of one of the blocks.
  204.  
  205.     f_YDist = 0.1; # plug in y value here
  206.     f_ZDist = 0.25; # plug in z value here            #changed from 3 for benefit of smallest block
  207.  
  208.     bSurfaceFound = 0;
  209.  
  210.     for (currentSurface = 0; (currentSurface < 5) && !bSurfaceFound; currentSurface = currentSurface + 1)
  211.     {
  212.         // Check to see if we're hanging off the left edge of our block surfaces.
  213.  
  214.         if (GetSenderRef() == hangR0[currentSurface])
  215.         {
  216.             f_XDist = hangDistR0[currentSurface];
  217.             bSurfaceFound = 1;
  218.         }
  219.     }
  220.  
  221.     if (!bSurfaceFound)
  222.     {
  223.         // We're not hanging off the right side - check for the left side.
  224.  
  225.         for (currentSurface = 0; (currentSurface < 6) && !bSurfaceFound; currentSurface = currentSurface + 1)
  226.         {
  227.             if (GetSenderRef() == hangL0[currentSurface])
  228.             {
  229.                 f_XDist = hangDistL0[currentSurface];
  230.                 bSurfaceFound = 1;
  231.             }
  232.         }
  233.     }
  234.  
  235.     # Establish a target near Indy at f_XDist, f_Ydist, f_ZDist
  236.     # Fill in offsets as needed.  0.1 = 1m
  237.     # Positive values are right (x) and forward (y) of thing center
  238.     # Z values are offset from thing center (itself offset from insert point)
  239.     # The mysterious zero vector parm in CreateThingAtPos() is for PYR
  240.     # xdist (defined above) is one half of block height, plus one
  241.  
  242.     # Create an invisible box above Indy.  (used in "Touched" section)
  243.  
  244.     if (bSurfaceFound)
  245.     {
  246.         v_modvec = VectorSet(f_XDist, f_YDist, f_ZDist);
  247.         v_targetpos = VectorAdd(VectorTransformToOrient(player, v_modvec), GetThingPos(player));    
  248.         targetsector = FindNewSectorFromThing(player, v_targetpos);
  249.         if (invisiBox != -1)
  250.         {
  251.             DetachThing(invisiBox);
  252.             DestroyThing(invisiBox);
  253.         }
  254.         invisiBox = CreateThingAtPos(boxTpl, targetsector, v_targetpos, '0 0 0');
  255.         CaptureThing(invisiBox); # no capture, no work
  256.         AttachThingToThing(invisiBox, player); # track his move
  257.     }
  258.  
  259.     if ((GetSenderID() == 1)&& ((GetSenderRef() != triggerFace) || (GetSenderRef() != retractFace)))
  260.     {
  261.         hanging = 1;
  262.     }
  263.     return;
  264.  
  265. # ========================================================================================
  266. exited:
  267.  
  268.     # Destroy the invisible box created when Indy was hanging.
  269.  
  270.     bSurfaceFound = 0;
  271.  
  272.     for (currentSurface = 0; (currentSurface < 5) && !bSurfaceFound; currentSurface = currentSurface + 1)
  273.         if (GetSenderRef() == hangR0[currentSurface])
  274.             bSurfaceFound = 1;
  275.  
  276.     if (!bSurfaceFound)
  277.         for (currentSurface = 0; (currentSurface < 6) && !bSurfaceFound; currentSurface = currentSurface + 1)
  278.             if (GetSenderRef() == hangL0[currentSurface])
  279.                 bSurfaceFound = 1;
  280.  
  281.     if (bSurfaceFound && invisiBox != -1)
  282.     {
  283.         DetachThing(invisiBox);
  284.         DestroyThing(invisiBox);
  285.         invisiBox = -1;
  286.     }
  287.  
  288.     if ((GetSenderID() == 1) && (hanging == 1))
  289.     {
  290.         hanging=0;
  291.     }
  292.  
  293. return;
  294.  
  295. # ........................................................................................
  296. pulse:
  297.  
  298.     # Move each block out
  299.     counter = counter + 1;
  300.     SetThingFlags(fakeBlock0[counter], 0x80000);
  301.     ClearThingFlags(block0[counter], 0x80000);
  302.     #PlaySoundThing(blocksnd, block0[counter], 1.0, 7.5, 30.0, 0);
  303.     MoveThingToPos(block0[counter], GetThingPos(blockGhost0[counter]), movespeed);
  304.     out0[counter] = 0;
  305.  
  306.     if (counter == 5)
  307.     {
  308.         SetPulse(0);
  309.         counter = 0;
  310.         retractCounter = 5;
  311.     }
  312.     return;
  313.  
  314. # ........................................................................................    
  315. arrived:
  316.  
  317.     bBlockFound=0;
  318.  
  319.     for (currentBlock = 0; (currentBlock <= 5) && !bBlockFound; currentBlock = currentBlock + 1)
  320.         if ((GetSenderRef() == Block0[currentBlock]))
  321.             bBlockFound = 1;
  322.  
  323.     if (!bBlockFound)
  324.         return;
  325.  
  326.     currentBlock = currentBlock - 1;
  327.  
  328.     # "Out" is "0" when the blocks are moving out.
  329.     if (out0[currentBlock] == 0)
  330.     {
  331.         ClearSurfaceFlags(hangR0[currentBlock], 0x1000000);
  332.         ClearSurfaceFlags(hangL0[currentBlock], 0x1000000);
  333.         ClearSurfaceFlags(hangE0[currentBlock], 0x1000000);
  334.         out0[currentBlock] = 1;
  335.                 
  336.         if (hanging == 1)
  337.         {
  338.             SetActorFlags(player, 0x200000);
  339.             DetachThing(player);
  340.         }
  341.  
  342.         if (GetSenderRef() == Block5)
  343.         {
  344.             SetTimer(autoRetract);
  345.         }
  346.  
  347.         return;
  348.     }
  349.     else
  350.     {
  351.         # "Out" is "1" when the blocks are moving back in.
  352.  
  353.         #SetThingFlags(Block0[currentBlock], 0x80000);
  354.         #ClearThingFlags(FakeBlock0[currentBlock], 0x80000);
  355.  
  356.         SetSurfaceFlags(hangR0[currentBlock], 0x1000000);
  357.         SetSurfaceFlags(hangL0[currentBlock], 0x1000000);
  358.         SetSurfaceFlags(hangE0[currentBlock], 0x1000000);
  359.         
  360.         out0[currentBlock] = 0;
  361.  
  362.         if (GetSenderRef() == Block0)
  363.         {
  364.             crosscheck = 0;
  365.         }
  366.  
  367.         return;
  368.     }
  369.  
  370.  
  371.     
  372.     #if ((hanging == 1) && (GetSenderRef() == block0[counter]))
  373.     #{
  374.     #    if (invisiBox != -1)
  375.     #    {
  376.     #        DetachThing(invisiBox);
  377.     #        DestroyThing(invisiBox);
  378.     #        invisiBox = -1;
  379.     #    }
  380.     #    SetActorFlags(player, 0x200000);
  381.     #    DetachThing(player);
  382.     #    ClearSurfaceFlags(hangR0, 0x1000000);
  383.     #    ClearSurfaceFlags(hangL0, 0x1000000);
  384.     #    ClearSurfaceFlags(hangE0, 0x1000000);
  385.     #}
  386.     
  387.     return;   
  388. # ........................................................................................
  389. timer:
  390.     # Retract all of the blocks
  391.  
  392.     if (retractCounter >= 0)
  393.     {
  394.         #PlaySoundThing(blocksnd, block0[retractCounter], 1.0, 7.5, 30.0, 0);
  395.         #MoveToFrame(block0[retractCounter], 0, autoRetractSpeed);
  396.         MoveThingToPos(block0[retractCounter], GetThingPos(backGhost0[retractCounter]), autoretractSpeed);
  397.         out0[retractCounter] = 1;
  398.         retractCounter = retractCounter - 1;
  399.         SetTimer(5.0);
  400.     }
  401.     return;
  402.  
  403. # ........................................................................................
  404. touched:    
  405.  
  406.     if (GetSourceRef() == player)
  407.         return;
  408.  
  409.     if (GetSenderRef() == invisiBox)
  410.     {
  411.         Print("Sender is invisiBox!");
  412.         SetActorFlags(player, 0x200000);
  413.         if (invisiBox != -1)
  414.         {
  415.             DetachThing(invisiBox);
  416.             DestroyThing(invisiBox);
  417.             invisiBox = -1;
  418.         }
  419.         DetachThing(player);
  420.     }
  421.  
  422.     return;
  423.     
  424. # ........................................................................................
  425. blocked:
  426. Print("blocked");
  427.  
  428. if (GetSenderRef() == block5)
  429. {
  430.     Sleep(0.5);
  431.     Print("inside blocked if statement");
  432.     MoveThingToPos(block5, GetThingPos(blockGhost5), movespeed);
  433. }
  434. if (GetSenderRef() == block4)
  435. {
  436.     Sleep(0.5);
  437.     Print("inside blocked if statement");
  438.     MoveThingToPos(block4, GetThingPos(blockGhost4), movespeed);
  439. }
  440.  
  441. return;
  442. # ........................................................................................
  443. end
  444.